

import java.util.*;

/*回溯算法实际就是深度优先遍历*/
public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String[] s = sc.nextLine().trim().split(" ");
            int len = s.length;
            int[] nums = new int[len];
            for (int i = 0; i < len; i++) {
                nums[i] = Integer.parseInt(s[i]);
            }
            System.out.println(Arrays.toString(permute(nums).toArray()));
        }

    }
    /*这个函数负责先处理数据，因为递归需要传入其他数据
    * 注意点：
    * 如果是牛客网的那样输入输出，是可以把元素定义在函数外面，这样就可以减少传参数
    * 其实都可以定义在外面
    **/

    public static List<List<Integer>> permute(int[] arr) {
        int len = arr.length;
        /*注意在new之前判断一下是不是可以不new即增加判空*/
        List<List<Integer>> res = new ArrayList<>();
        if (len == 0) {
            return res;
        }
        Deque<Integer> stack = new ArrayDeque<>();
        boolean[] used = new boolean[len];
        dfs(arr, len, 0, stack, used, res);
        return res;
    }


    // 好好体会一下深度优先遍历，具有可重用性
    public static void dfs (int[] arr, int len, int depth, Deque<Integer> stack, boolean[] used, List<List<Integer>> res) {
        if (len == depth) {
            res.add(new ArrayList<>(stack));
            return;
        }
        for (int i = 0; i < len; i++) {
            if (used[i]) {
                continue;
            }
            stack.push(arr[i]);
            used[i] = true;
            dfs(arr, len, depth+1, stack, used, res);
            used[i] = false;
            stack.pop();
        }
    }





}
